#include "zgl.h"
#include "msghandling.h"

void glopMaterial(GLContext* c, GLParam* p) {
  int mode = p[1].i;
  int type = p[2].i;
  float* v = &p[3].f;
  int i;
  GLMaterial* m;

  if (mode == GL_FRONT_AND_BACK) {
    p[1].i = GL_FRONT;
    glopMaterial(c, p);
    mode = GL_BACK;
  }
  if (mode == GL_FRONT)
    m = &c->materials[0];
  else
    m = &c->materials[1];

  switch (type) {
    case GL_EMISSION:
      for (i = 0; i < 4; i++) m->emission.v[i] = v[i];
      break;
    case GL_AMBIENT:
      for (i = 0; i < 4; i++) m->ambient.v[i] = v[i];
      break;
    case GL_DIFFUSE:
      for (i = 0; i < 4; i++) m->diffuse.v[i] = v[i];
      break;
    case GL_SPECULAR:
      for (i = 0; i < 4; i++) m->specular.v[i] = v[i];
      break;
    case GL_SHININESS:
      m->shininess = v[0];
      m->shininess_i = (v[0] / 128.0f) * SPECULAR_BUFFER_RESOLUTION;
      break;
    case GL_AMBIENT_AND_DIFFUSE:
      for (i = 0; i < 4; i++) m->diffuse.v[i] = v[i];
      for (i = 0; i < 4; i++) m->ambient.v[i] = v[i];
      break;
    default:
      assert(0);
  }
}

void glopColorMaterial(GLContext* c, GLParam* p) {
  int mode = p[1].i;
  int type = p[2].i;

  c->current_color_material_mode = mode;
  c->current_color_material_type = type;
}

void glopLight(GLContext* c, GLParam* p) {
  int light = p[1].i;
  int type = p[2].i;
  V4 v;
  GLLight* l;
  int i;

  assert(light >= GL_LIGHT0 && light < GL_LIGHT0 + MAX_LIGHTS);

  l = &c->lights[light - GL_LIGHT0];

  for (i = 0; i < 4; i++) v.v[i] = p[3 + i].f;

  switch (type) {
    case GL_AMBIENT:
      l->ambient = v;
      break;
    case GL_DIFFUSE:
      l->diffuse = v;
      break;
    case GL_SPECULAR:
      l->specular = v;
      break;
    case GL_POSITION: {
      V4 pos;
      gl_M4_MulV4(&pos, c->matrix_stack_ptr[0], &v);

      l->position = pos;

      if (l->position.v[3] == 0) {
        l->norm_position.X = pos.X;
        l->norm_position.Y = pos.Y;
        l->norm_position.Z = pos.Z;

        gl_V3_Norm(&l->norm_position);
      }
    } break;
    case GL_SPOT_DIRECTION:
      for (i = 0; i < 3; i++) {
        l->spot_direction.v[i] = v.v[i];
        l->norm_spot_direction.v[i] = v.v[i];
      }
      gl_V3_Norm(&l->norm_spot_direction);
      break;
    case GL_SPOT_EXPONENT:
      l->spot_exponent = v.v[0];
      break;
    case GL_SPOT_CUTOFF: {
      float a = v.v[0];
      assert(a == 180 || (a >= 0 && a <= 90));
      l->spot_cutoff = a;
      if (a != 180) l->cos_spot_cutoff = cos(a * M_PI / 180.0);
    } break;
    case GL_CONSTANT_ATTENUATION:
      l->attenuation[0] = v.v[0];
      break;
    case GL_LINEAR_ATTENUATION:
      l->attenuation[1] = v.v[0];
      break;
    case GL_QUADRATIC_ATTENUATION:
      l->attenuation[2] = v.v[0];
      break;
    default:
      assert(0);
  }
}

void glopLightModel(GLContext* c, GLParam* p) {
  int pname = p[1].i;
  float* v = &p[2].f;
  int i;

  switch (pname) {
    case GL_LIGHT_MODEL_AMBIENT:
      for (i = 0; i < 4; i++) c->ambient_light_model.v[i] = v[i];
      break;
    case GL_LIGHT_MODEL_LOCAL_VIEWER:
      c->local_light_model = (int)v[0];
      break;
    case GL_LIGHT_MODEL_TWO_SIDE:
      c->light_model_two_side = (int)v[0];
      break;
    default:
      tgl_warning("glopLightModel: illegal pname: 0x%x\n", pname);
      //assert(0);
      break;
  }
}

static inline float clampf(float a, float min, float max) {
  if (a < min)
    return min;
  else if (a > max)
    return max;
  else
    return a;
}

void gl_enable_disable_light(GLContext* c, int light, int v) {
  GLLight* l = &c->lights[light];
  if (v && !l->enabled) {
    l->enabled = 1;
    l->next = c->first_light;
    c->first_light = l;
    l->prev = NULL;
  } else if (!v && l->enabled) {
    l->enabled = 0;
    if (l->prev == NULL)
      c->first_light = l->next;
    else
      l->prev->next = l->next;
    if (l->next != NULL) l->next->prev = l->prev;
  }
}

/* non optimized lightening model */
void gl_shade_vertex(GLContext* c, GLVertex* v) {
  float R, G, B, A;
  GLMaterial* m;
  GLLight* l;
  V3 n, s, d;
  float dist, tmp, att, dot, dot_spot, dot_spec;
  int twoside = c->light_model_two_side;

  m = &c->materials[0];

  n.X = v->normal.X;
  n.Y = v->normal.Y;
  n.Z = v->normal.Z;

  R = m->emission.v[0] + m->ambient.v[0] * c->ambient_light_model.v[0];
  G = m->emission.v[1] + m->ambient.v[1] * c->ambient_light_model.v[1];
  B = m->emission.v[2] + m->ambient.v[2] * c->ambient_light_model.v[2];
  A = clampf(m->diffuse.v[3], 0, 1);

  for (l = c->first_light; l != NULL; l = l->next) {
    float lR, lB, lG;

    /* ambient */
    lR = l->ambient.v[0] * m->ambient.v[0];
    lG = l->ambient.v[1] * m->ambient.v[1];
    lB = l->ambient.v[2] * m->ambient.v[2];

    if (l->position.v[3] == 0) {
      /* light at infinity */
      d.X = l->position.v[0];
      d.Y = l->position.v[1];
      d.Z = l->position.v[2];
      att = 1;
    } else {
      /* distance attenuation */
      d.X = l->position.v[0] - v->ec.v[0];
      d.Y = l->position.v[1] - v->ec.v[1];
      d.Z = l->position.v[2] - v->ec.v[2];
      dist = sqrt(d.X * d.X + d.Y * d.Y + d.Z * d.Z);
      if (dist > 1E-3) {
        tmp = 1 / dist;
        d.X *= tmp;
        d.Y *= tmp;
        d.Z *= tmp;
      }
      att = 1.0f / (l->attenuation[0] + dist * (l->attenuation[1] + dist * l->attenuation[2]));
    }
    dot = d.X * n.X + d.Y * n.Y + d.Z * n.Z;
    if (twoside && dot < 0) dot = -dot;
    if (dot > 0) {
      /* diffuse light */
      lR += dot * l->diffuse.v[0] * m->diffuse.v[0];
      lG += dot * l->diffuse.v[1] * m->diffuse.v[1];
      lB += dot * l->diffuse.v[2] * m->diffuse.v[2];

      /* spot light */
      if (l->spot_cutoff != 180) {
        dot_spot = -(d.X * l->norm_spot_direction.v[0] + d.Y * l->norm_spot_direction.v[1] +
                     d.Z * l->norm_spot_direction.v[2]);
        if (twoside && dot_spot < 0) dot_spot = -dot_spot;
        if (dot_spot < l->cos_spot_cutoff) {
          /* no contribution */
          continue;
        } else {
          /* TODO: optimize */
          if (l->spot_exponent > 0) {
            att = att * pow(dot_spot, l->spot_exponent);
          }
        }
      }

      /* specular light */

      if (c->local_light_model) {
        V3 vcoord;
        vcoord.X = v->ec.X;
        vcoord.Y = v->ec.Y;
        vcoord.Z = v->ec.Z;
        gl_V3_Norm(&vcoord);
        s.X = d.X - vcoord.X;
        s.Y = d.Y - vcoord.X;
        s.Z = d.Z - vcoord.X;
      } else {
        s.X = d.X;
        s.Y = d.Y;
        s.Z = d.Z + 1.0;
      }
      dot_spec = n.X * s.X + n.Y * s.Y + n.Z * s.Z;
      if (twoside && dot_spec < 0) dot_spec = -dot_spec;
      if (dot_spec > 0) {
        GLSpecBuf* specbuf;
        int idx;
        tmp = sqrt(s.X * s.X + s.Y * s.Y + s.Z * s.Z);
        if (tmp > 1E-3) {
          dot_spec = dot_spec / tmp;
        }

        /* TODO: optimize */
        /* testing specular buffer code */
        /* dot_spec= pow(dot_spec,m->shininess);*/
        specbuf = specbuf_get_buffer(c, m->shininess_i, m->shininess);
        idx = (int)(dot_spec * SPECULAR_BUFFER_SIZE);
        if (idx > SPECULAR_BUFFER_SIZE) idx = SPECULAR_BUFFER_SIZE;
        dot_spec = specbuf->buf[idx];
        lR += dot_spec * l->specular.v[0] * m->specular.v[0];
        lG += dot_spec * l->specular.v[1] * m->specular.v[1];
        lB += dot_spec * l->specular.v[2] * m->specular.v[2];
      }
    }

    R += att * lR;
    G += att * lG;
    B += att * lB;
  }

  v->color.v[0] = clampf(R, 0, 1);
  v->color.v[1] = clampf(G, 0, 1);
  v->color.v[2] = clampf(B, 0, 1);
  v->color.v[3] = A;
}
